home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DClap / DTableView-c0.cpp < prev    next >
Text File  |  1996-07-05  |  32KB  |  1,324 lines
  1. // DTableView.cp
  2. // d.g.gilbert
  3.  
  4. // this class is used a lot for various display/user interaction arrays of items
  5. // still needs work for multiple selections, run arrays for height/width?
  6. // 
  7.  
  8. #include "DTableView.h"
  9. #include <DPanel.h>
  10. #include <DUtil.h>
  11. #include <DApplication.h>
  12. #include <Dvibrant.h>
  13. #include <DTracker.h>
  14. #include <ncbi.h>
  15. #include <dgg.h>
  16.  
  17.  
  18.  
  19.  
  20. DTabSelector::DTabSelector( DTableView* itsTable)
  21. {
  22.     ITabSelector( itsTable); // in constructor !?
  23. }
  24.  
  25. DTabSelector::~DTabSelector() 
  26. {
  27. #if 0
  28.     fOldSelection= Nlm_DestroyRgn( fOldSelection);
  29.     fNewSelection= Nlm_DestroyRgn( fNewSelection);
  30. #endif
  31. }
  32.  
  33. void DTabSelector::ITabSelector( DTableView* itsTable)
  34. {
  35.     ITracker( cTabSelCmd, itsTable, "selection", true, false, itsTable); 
  36.     // ITracker() calls Reset()
  37. }
  38.  
  39.  
  40. void DTabSelector::Reset()
  41. {
  42.     DTracker::Reset();
  43.     fDoExtend= gKeys->shift();
  44. #if 1
  45.     fOldSelection= ((DTableView*)fView)->GetSelRect();
  46.     fNewSelection= fOldSelection;
  47. #else
  48.     fOldSelection= Nlm_NewRgn(); 
  49.     fNewSelection= Nlm_NewRgn();  
  50.     CopyRgn( ((DTableView*)fView)->fSelections, fOldSelection);
  51.     CopyRgn( fOldSelection, fNewSelection);
  52. #endif
  53. }
  54.  
  55.  
  56. void DTabSelector::DoItWork()  
  57. {
  58.     if (fMovedOnce || fDoExtend) {
  59.         ((DTableView*)fView)->SelectCells( fNewSelection, 
  60.                 fDoExtend, DTableView::kHighlight, DTableView::kSelect);
  61.         }
  62. }
  63.  
  64. void DTabSelector::UndoWork()  
  65. {
  66. #if 1
  67.     Nlm_RecT tmpRect= fNewSelection;
  68.     fNewSelection= fOldSelection;
  69.     fOldSelection= tmpRect;
  70. #else
  71.     Nlm_RgN tmpRgn= fNewSelection;
  72.     fNewSelection= fOldSelection;
  73.     fOldSelection= tmpRgn;
  74. #endif
  75.     DoItWork();
  76. }
  77.  
  78.  
  79. void DTabSelector::DoIt()  
  80. {
  81.     DCommand::DoIt();
  82.     
  83.     Nlm_PoinT pt1, pt2;
  84.     Nlm_RecT    selr;
  85.         // +1 is messy fix to stop left/top -1 creap !
  86.     pt1.x= MIN( fAnchorPoint.x+1, fNextPoint.x);
  87.     pt2.x= MAX( fAnchorPoint.x-1, fNextPoint.x);
  88.     pt1.y= MIN( fAnchorPoint.y+1, fNextPoint.y);
  89.     pt2.y= MAX( fAnchorPoint.y-1, fNextPoint.y);
  90.  
  91.     ((DTableView*)fView)->PointToCell( pt1, selr.top, selr.left);
  92.     ((DTableView*)fView)->PointToCell( pt2, selr.bottom, selr.right);
  93.     selr.bottom++;
  94.     selr.right++;
  95.     fNewSelection= selr;
  96.     if (!fDoExtend) fDoExtend= gKeys->shift(); // give'em another chance to shift
  97.     
  98.     DoItWork();
  99. }
  100.  
  101. void DTabSelector::Undo()  
  102. {
  103.     DCommand::Undo();
  104.     Boolean saveext= fDoExtend;
  105.     fDoExtend= false;
  106.     UndoWork();
  107.     fDoExtend= saveext;
  108. }
  109.  
  110. void DTabSelector::Redo()  
  111. {
  112.     DCommand::Redo();
  113.     UndoWork();
  114. }
  115.  
  116.  
  117.  
  118.  
  119.  
  120.  
  121.  
  122. //class DTableView : public DPanel
  123.  
  124.  
  125. DTableView::DTableView(long id, DView* itsSuperior, short pixwidth, short pixheight, 
  126.                                                 short nrows, short ncols, short itemwidth, short itemheight,
  127.                                                 Boolean hasVscroll, Boolean hasHscroll):
  128.         DAutoPanel( id, itsSuperior, pixwidth, pixheight, hasVscroll, hasHscroll),
  129.         fItemWidth(itemwidth), fItemHeight(itemheight),
  130.         fTop(0), fLeft(0), fColsDrawn(0), fMaxRows(nrows), fMaxCols(ncols), 
  131.         fSelectedRow(kNoSelection), fSelectedCol(kNoSelection),
  132.         fCanSelectRow(true), fCanSelectCol(false),fIsPrinting(false),
  133.         fWidths(NULL), fHeights(NULL),
  134.         fFont(Nlm_programFont)
  135. {
  136.     Nlm_BaR sb;
  137.     sb = Nlm_GetSlateVScrollBar((Nlm_SlatE) GetNlmObject());
  138.   fHasVbar= (sb != NULL);
  139.   sb = Nlm_GetSlateHScrollBar((Nlm_SlatE) GetNlmObject());
  140.   fHasHbar= (sb != NULL);
  141.   FindLocation();
  142.   SetTableSize( fMaxRows, fMaxCols);
  143.     SetEmptySelection(false); 
  144.     
  145.     fTabSelector= new DTabSelector( this);
  146.     //fTabSelector->ITabSelector( this);
  147.     fCurrentTracker= fTabSelector;
  148. }
  149.         
  150. DTableView::~DTableView()
  151. {
  152.     MemFree(fWidths);
  153.     MemFree(fHeights);
  154.     //if (fTabSelector) delete fTabSelector; //<< causing Motif crashes !?
  155. }
  156.  
  157. void DTableView::SetCanSelect(Boolean canrow, Boolean cancol)
  158. {
  159.     fCanSelectRow= canrow;
  160.     fCanSelectCol= cancol;
  161. }
  162.  
  163.  
  164. static Boolean didscroll;
  165.  
  166. void DTableView::SelectCells( short row, short col, 
  167.                         Nlm_Boolean extend, Nlm_Boolean highlight, Nlm_Boolean select)
  168. {
  169.     if (row>=fMaxRows || row<0 || col>=fMaxCols || col<0) return;
  170.  
  171.     if (highlight) InvertSelection(); // hide old
  172.     if (fCanSelectRow) fSelectedRow= row; 
  173.     if (fCanSelectCol) fSelectedCol= col;
  174.          
  175.     if (!select) ; // deselect cells !!
  176.     
  177.     if (extend) {
  178.         if (fSelrect.top == kNoSelection) fSelrect.top= row;
  179.         else if (fSelrect.top > row) fSelrect.top= row;
  180.         if (fSelrect.bottom <= row) fSelrect.bottom= row+1; 
  181.     
  182.         if (fSelrect.left == kNoSelection) fSelrect.left= col;
  183.         else if (fSelrect.left > col) fSelrect.left= col;
  184.         if (fSelrect.right <= col) fSelrect.right= col+1; 
  185.         }
  186.     else {
  187.         fSelrect.left= col;
  188.         fSelrect.right= col+1; 
  189.         fSelrect.top= row;
  190.         fSelrect.bottom= row+1; 
  191.         }
  192.         
  193.     didscroll= false;
  194.     ScrollIntoView( fSelrect);
  195.     if (!didscroll && highlight) InvertSelection(); // show new
  196. }
  197.  
  198. void DTableView::SelectCells( Nlm_RecT selrect,  
  199.                         Nlm_Boolean extend, Nlm_Boolean highlight, Nlm_Boolean select)
  200. {
  201.     if (selrect.top>= fMaxRows || selrect.bottom<0 
  202.      || selrect.left>=fMaxCols || selrect.right<0) return;
  203.     selrect.left= Max(0,selrect.left);
  204.     selrect.right= Min(fMaxCols, selrect.right);
  205.     selrect.top= Max(0,selrect.top);
  206.     selrect.bottom= Min(fMaxRows, selrect.bottom);
  207.     
  208.     if (highlight) InvertSelection();  
  209.     if (fCanSelectRow) fSelectedRow= selrect.top; 
  210.     if (fCanSelectCol) fSelectedCol= selrect.left;
  211.     
  212.     if (extend)  {
  213.         if (fSelrect.top == kNoSelection) fSelrect.top= selrect.top;
  214.         if (fSelrect.bottom == kNoSelection) fSelrect.bottom= selrect.bottom;
  215.         if (fSelrect.left == kNoSelection) fSelrect.left= selrect.left;
  216.         if (fSelrect.right == kNoSelection) fSelrect.right= selrect.right;
  217.       Nlm_UnionRect( &fSelrect, &selrect, &fSelrect);
  218.       }
  219.     else   
  220.         fSelrect= selrect; // ?? add +1 to .right & .bottom ??
  221.  
  222.     didscroll= false;
  223.     ScrollIntoView( fSelrect);
  224.     if (!didscroll && highlight) InvertSelection();  
  225. }
  226.  
  227.  
  228. void DTableView::ScrollIntoView(Nlm_RecT itemr)
  229. {
  230.     enum { horizontal= false, vertical= true };
  231.     short    lastitem;
  232.     long    atpix;
  233.     Nlm_BaR sb;
  234.  
  235.      // fItemWidth << this isn't accurate for variable width/height.
  236.     if (fWidths) {
  237.         for (lastitem= fLeft, atpix= 0; lastitem< fMaxCols; lastitem++) { 
  238.             atpix += fWidths[lastitem]; 
  239.             if (atpix > fRect.right) break;
  240.             }
  241.         }
  242.     else
  243.         lastitem= fLeft + (fRect.right - fRect.left)/fItemWidth;
  244.      
  245.     if (itemr.left > lastitem || itemr.left < fLeft) {
  246.          didscroll= true;
  247.         sb = Nlm_GetSlateHScrollBar((Nlm_SlatE) GetNlmObject());
  248.         if (sb) { 
  249.             //Nlm_ResetClip(); // ! TEST: are we losing scrollbar update due to cliprect?
  250.             Nlm_SetValue(sb, Max(0, itemr.left - 1));  // calls our scroll funct
  251.             }
  252.         }
  253.     
  254.     if (fHeights) {
  255.         for (lastitem= fTop, atpix= 0; lastitem< fMaxRows; lastitem++) { 
  256.             atpix += fHeights[lastitem]; 
  257.             if (atpix > fRect.bottom) break;
  258.             }
  259.         }
  260.     else
  261.         lastitem= fTop + (fRect.bottom - fRect.top)/fItemHeight;
  262.         
  263.     if (itemr.top > lastitem || itemr.top < fTop) {
  264.          didscroll= true;
  265.         sb = Nlm_GetSlateVScrollBar((Nlm_SlatE) GetNlmObject());
  266.         if (sb) Nlm_SetValue(sb,  Max(0, itemr.top - 1));  
  267.         }
  268. }
  269.  
  270.  
  271. void DTableView::SetEmptySelection(Boolean redraw)
  272. {
  273.     if (redraw) {
  274.         //InvertSelection();
  275.         InvalidateSelection();
  276.         }
  277.     fSelectedRow = kNoSelection;
  278.     fSelectedCol = kNoSelection;
  279.     //Nlm_SetRect
  280.     Nlm_LoadRect( &fSelrect, kNoSelection, kNoSelection, kNoSelection, kNoSelection);
  281. }
  282.  
  283. void DTableView::InvalidateSelection()
  284. {
  285.     Nlm_RecT r, r2;
  286.     if (!Nlm_EmptyRect(&fSelrect)) {
  287.         r2= fSelrect;
  288.         GetCellRect( r2, r);
  289.         InvalRect( r);
  290.         }
  291.     else if (fSelectedRow>=0 && fSelectedCol>=0) {
  292.         GetCellRect( fSelectedRow, fSelectedCol, r);
  293.         InvalRect( r);
  294.         }
  295.     else if (fSelectedRow>=0) {
  296.         GetRowRect( fSelectedRow, r);
  297.         InvalRect( r);
  298.         }
  299.     else if (fSelectedCol>=0) {
  300.         GetRowRect( fSelectedCol, r);
  301.         InvalRect( r);
  302.         }
  303. }
  304.  
  305.  
  306. Boolean DTableView::IsSelected()
  307. {
  308.     return (!Nlm_EmptyRect( &fSelrect));
  309.     //return (fSelectedRow == kNoSelection && fSelectedCol == kNoSelection);
  310. } 
  311.  
  312.  
  313. Boolean DTableView::IsSelected(short row, short col)
  314. {
  315.     Nlm_PoinT pt;
  316.     pt.y= row; pt.x= col;
  317.     Boolean issel= Nlm_PtInRect( pt, &fSelrect);
  318.     return issel;
  319. }  
  320.  
  321.  
  322.  
  323.  
  324. void DTableView::SetTableFont( Nlm_FonT itsFont)
  325. {
  326.     fFont= itsFont;
  327. }
  328.  
  329. void DTableView::SetTableSize( short rows, short cols)
  330. {
  331.     short i;
  332.     
  333.     if (fWidths && cols!=fMaxCols) {
  334.         fWidths= (short*)MemMore( fWidths, (cols+1) * sizeof(short));
  335.         for (i= fMaxCols; i<=cols; i++) fWidths[i]= fItemWidth;
  336.         }
  337.         
  338.     if (fHeights && rows!=fMaxRows) {
  339.         fHeights= (short*)MemMore( fHeights, (rows+1) * sizeof(short));
  340.         for (i= fMaxRows; i<=rows; i++) fHeights[i]= fItemHeight;
  341.         }
  342.     
  343.     fMaxRows= rows; 
  344.     fMaxCols= cols;
  345.  
  346.     SetScrollPage();
  347. }
  348.  
  349. void DTableView::ChangeRowSize( short atrow, short deltarows)
  350. {
  351.     Boolean needupdate;
  352.     short newrows= Max(0, fMaxRows + deltarows);
  353. #if 1
  354.     Nlm_RecT  r;
  355.     ViewRect(fRect); 
  356.     Nlm_InsetRect( &fRect, 1, 1);
  357.     GetRowRect( atrow, r, (fMaxRows - atrow));
  358.     needupdate= Nlm_SectRect( &r, &fRect, &r);
  359.     SetTableSize( newrows, fMaxCols);
  360.     if (needupdate) this->InvalRect( r);
  361. #else
  362.     short viewrows=  (fRect.bottom - fRect.top) / fItemHeight;
  363.     needupdate= (atrow >= fTop && atrow <= viewrows);
  364.         // ^^ needs work
  365.     SetTableSize( newrows, fMaxCols);
  366.     if (needupdate) {
  367.         //this->Invalidate(); // locate just update rect??    
  368.         Nlm_RecT r;
  369.         short nrows= viewrows - atrow;
  370.         GetRowRect( atrow, r, nrows);
  371.         this->InvalRect( r);
  372.         }
  373. #endif
  374. }
  375.  
  376. void DTableView::ChangeColSize( short atcol, short deltacols)
  377. {
  378.     short newcols= Max(0, fMaxCols + deltacols);
  379.     Boolean needupdate= (atcol >= fLeft && atcol <= (fRect.right - fRect.left) / fItemWidth);
  380.         // ^^ needs work
  381.     SetTableSize( fMaxRows, newcols);
  382.     if (needupdate) {
  383.         //this->Invalidate(); // locate just update rect??    
  384.         Nlm_RecT r;
  385.         short ncols= ((fRect.right - fRect.left) / fItemWidth) - atcol;
  386.         GetColRect( atcol, r, ncols);
  387.         this->InvalRect( r);
  388.         }
  389. }
  390.  
  391.         
  392. void DTableView::SetItemWidth(short atcol, short ncols, short itemwidth)
  393. {
  394.     short i;
  395.     if (ncols >= fMaxCols && !fWidths) {
  396.         fItemWidth= itemwidth;
  397.         }
  398.     else {
  399.         if (!fWidths) {
  400.             // make fWidths
  401.             fWidths= (short*)MemNew( (fMaxCols+1)*sizeof(short));
  402.             for (i= 0; i<=fMaxCols; i++) fWidths[i]= fItemWidth;
  403.             }
  404.         short ncol= Min(fMaxCols, atcol+ncols);
  405.         for (i= atcol; i<ncol; i++) fWidths[i]= itemwidth;
  406.     fItemWidth= Max( fItemWidth, itemwidth);
  407.         }
  408.   SetScrollPage();
  409. }
  410.  
  411. void DTableView::SetItemHeight(short atrow, short nrows, short itemheight)
  412. {
  413.     short i;
  414.     if (nrows >= fMaxRows && !fHeights) {
  415.         fItemHeight= itemheight;
  416.         }
  417.     else {
  418.         if (!fHeights) {
  419.             fHeights= (short*)MemNew( (fMaxRows+1)*sizeof(short));
  420.             for (i= 0; i<=fMaxRows; i++) fHeights[i]= fItemHeight;
  421.             }
  422.         short nrow= Min(fMaxRows, atrow+nrows);
  423.         for (i= atrow; i<nrow; i++) fHeights[i]= itemheight;
  424. #if 0
  425.     if (itemheight) fItemHeight= MIN( fItemHeight, itemheight);
  426. #else
  427.     fItemHeight= MAX( fItemHeight, itemheight);
  428. #endif
  429.         }
  430.   SetScrollPage();
  431. }
  432.         
  433. void DTableView::SetScrollPage()
  434. {
  435.     // set paging size of hor/vert sbars.. need to do on open & on resize
  436.     Nlm_BaR sb;
  437.     short pgDn, pg, maxn;
  438.     if (fHasHbar) {
  439.         pg= (fRect.right - fRect.left) / fItemWidth;
  440.         pgDn= Max(1, pg - 1);
  441.         maxn= Max( fMaxCols - pgDn, 1);
  442.         sb = Nlm_GetSlateHScrollBar((Nlm_SlatE) GetNlmObject());
  443.         if (sb) Nlm_SetRange(sb, pgDn, pgDn, maxn);
  444.         }
  445.     if (fHasVbar) {
  446.         pg= (fRect.bottom - fRect.top) / fItemHeight;
  447.         pgDn= Max(1, pg - 1);
  448.         maxn= Max( fMaxRows - pgDn, 1);
  449.         sb = Nlm_GetSlateVScrollBar((Nlm_SlatE) GetNlmObject());
  450.         if (sb) Nlm_SetRange(sb, pgDn, pgDn, maxn);
  451.         }
  452. }
  453.  
  454. void DTableView::FindLocation()
  455. {
  456.     ViewRect(fRect); //this->GetPosition(fRect); // ?? this isn't changing except w/ resize ??
  457.     Nlm_InsetRect( &fRect, 1, 1);
  458.     SetScrollPage();
  459. }
  460.         
  461. void DTableView::SizeToSuperview( DView* super, Boolean horiz, Boolean vert)
  462. {
  463. #ifndef WIN_MSWIN
  464.     DView::SizeToSuperview(super, horiz, vert);
  465. #else
  466.     Nlm_RecT r, myr;
  467.     super->ViewRect(r);
  468.     ViewRect(myr);
  469.             // these sizes draw off by -1... thus the +1
  470.     if (horiz) {
  471.         myr.left = 0;
  472.         myr.right= myr.left + (r.right - r.left) +1;
  473. #ifdef WIN_MSWIN
  474.         if (fHasVbar) myr.right -= (Nlm_vScrollBarWidth - 8);
  475. #endif
  476.         }
  477.     if (vert) {
  478.         myr.top = 0;
  479.         myr.bottom = myr.top + (r.bottom - r.top) +1;
  480. #ifdef WIN_MSWIN
  481.         if (fHasHbar) myr.bottom -= (Nlm_hScrollBarHeight + 10);
  482. #endif
  483.         }
  484.     SetPosition( myr);
  485. #endif
  486.     this->FindLocation(); //?? added 14Mar94, gopher tables were doing this
  487. }
  488.  
  489.  
  490. void DTableView::Resize(DView* superview, Nlm_PoinT sizechange)
  491. {
  492.         // !! need this fRect change to deal w/ Resize() update event, 
  493.         // which isn't put in a nice event queue, but is done immediately !!
  494.     fRect.right  += sizechange.x;
  495.     fRect.bottom += sizechange.y;
  496.     DPanel::Resize(superview, sizechange);
  497.     FindLocation();
  498. }
  499.  
  500. void DTableView::Scroll(Boolean vertical, DView* scrollee, short newval, short oldval)
  501. {
  502.     Nlm_RecT    r = fRect;
  503.     short delta, i;
  504.     short diff= newval-oldval;
  505.     this->Select(); // need for motif !
  506.     if (vertical) {
  507.  
  508.       if (fHeights) {
  509.         delta= 0;
  510.             if (oldval>newval) {
  511.                 for (i=oldval-1; i>=newval; i--) delta -= fHeights[i];
  512.                 }
  513.         else {
  514.                 for (i=oldval; i<newval; i++) delta += fHeights[i];
  515.                 }
  516.             }
  517.         else
  518.             delta= diff * fItemHeight;
  519.  
  520.         fTop += diff;
  521.         Nlm_ScrollRect (&r, 0, -delta);
  522.         if (diff<0) r.bottom= r.top - delta + Min(10,-delta/2);
  523.         else r.top= r.bottom - delta - Min(10,delta/2);
  524.         }
  525.         
  526.     else {
  527. #if 1
  528.       if (fWidths) {
  529.         delta= 0;
  530.             if (oldval>newval) {
  531.                 for (i=oldval-1; i>=newval; i--) delta -= fWidths[i];
  532.                 }
  533.         else {
  534.                 for (i=oldval; i<newval; i++) delta += fWidths[i];
  535.                 }
  536.             }
  537.         else
  538.             delta= diff * fItemWidth;
  539.             
  540.         fLeft += diff;
  541.         Nlm_ScrollRect (&r, -delta, 0);
  542.         if (diff<0) r.right= Min(r.right, r.left - delta + Min(20,-delta/2));
  543.         else r.left= Max(r.left, r.right - delta - Min(20,delta/2));
  544. #else
  545.         if (fWidths) {
  546.             // fix later, for now redraw all w/o bitscroll
  547.             fLeft += diff;
  548.             }
  549.         else {
  550.             fLeft += diff;
  551.             delta= diff * fItemWidth;
  552.             Nlm_ScrollRect (&r, -delta, 0);
  553.             if (diff<0) r.right= r.left - delta + Min(10,-delta/2);
  554.             else r.left= r.right - delta - Min(10,delta/2);
  555.             }
  556. #endif
  557.         }
  558.     this->InvalRect( r);
  559.   Nlm_Update(); //!? need since took out vibwnds autoupdate for RestorePort
  560. }
  561.             
  562.  
  563. void DTableView::GetRowRect( short row, Nlm_RecT& r, short nrows)
  564. {
  565.     short i;
  566.     r= fRect;
  567.     if (fHeights) {
  568.         for (i= fTop; i<row; i++) r.top += fHeights[i];
  569.         r.bottom= r.top;
  570.         for (i= 0; i<nrows; i++) r.bottom += fHeights[row+i];
  571.         }
  572.     else {
  573.         r.top += (row-fTop) * fItemHeight;
  574.         r.bottom = r.top + nrows*fItemHeight;
  575.         }
  576. }
  577.  
  578. void DTableView::GetColRect( short col, Nlm_RecT& r, short ncols)
  579. {
  580.     short i;
  581.     r= fRect;
  582.     if (fWidths) {
  583.         for (i= fLeft; i<col; i++) r.left += fWidths[i];
  584.         r.right= r.left;
  585.         for (i= 0; i<ncols; i++) r.right += fWidths[col+i];
  586.         }
  587.     else {
  588.         r.left += (col-fLeft) * fItemWidth;
  589.         r.right = r.left + ncols*fItemWidth;
  590.         }
  591. }
  592.  
  593. void DTableView::GetCellRect( short row, short col, Nlm_RecT& r)
  594. {
  595.     short i;
  596.     r= fRect;
  597.     if (fWidths) {
  598.         for (i= fLeft; i<col; i++) r.left += fWidths[i];
  599.         r.right= r.left + fWidths[col];
  600.         }
  601.     else {
  602.         r.left += (col-fLeft) * fItemWidth;
  603.         r.right = r.left + fItemWidth;
  604.         }
  605.     if (fHeights) {
  606.         for (i= fTop; i<row; i++) r.top += fHeights[i];
  607.         r.bottom= r.top + fHeights[row];
  608.         }
  609.     else {
  610.         r.top += (row-fTop) * fItemHeight;
  611.         r.bottom = r.top + fItemHeight;
  612.         }
  613. }
  614.  
  615. void DTableView::GetCellRect(Nlm_RecT cellr, Nlm_RecT& r)
  616. {
  617.     short i;
  618.     r= fRect;
  619.     if (fWidths) {
  620.         for (i= fLeft; i<cellr.left; i++) r.left += fWidths[i];
  621.         r.right= r.left;
  622.         for (i=cellr.left; i<cellr.right; i++) r.right += fWidths[i];
  623.         }
  624.     else {
  625.         r.left += (cellr.left-fLeft) * fItemWidth;
  626.         r.right = r.left + (cellr.right - cellr.left) * fItemWidth;
  627.         }
  628.         
  629.     if (fHeights) {
  630.         for (i= fTop; i<cellr.top; i++) r.top += fHeights[i];
  631.         r.bottom= r.top;
  632.         for (i=cellr.top; i<cellr.bottom; i++) r.bottom += fHeights[i];
  633.         }
  634.     else {
  635.         r.top += (cellr.top-fTop) * fItemHeight;
  636.         r.bottom = r.top + (cellr.bottom - cellr.top) * fItemHeight;
  637.         }
  638. }
  639.  
  640.     
  641. short DTableView::GetSelectedRow()
  642. { 
  643.     return fSelectedRow; 
  644. }
  645.  
  646. short DTableView::GetSelectedCol() 
  647. { 
  648.     return fSelectedCol; 
  649. }
  650.  
  651. void DTableView::GetFirstSelectedCell( short& row, short& col)
  652. { 
  653. #if 0
  654.     row= fSelectedRow; 
  655.     col= fSelectedCol; 
  656. #else
  657.     row= fSelrect.top;
  658.     col= fSelrect.left;
  659. #endif
  660. }
  661.  
  662. void DTableView::GetLastSelectedCell( short& row, short& col)
  663. { 
  664. #if 0
  665.     row= fSelectedRow; 
  666.     col= fSelectedCol; 
  667. #else
  668.     row= fSelrect.bottom;
  669.     col= fSelrect.right;
  670. #endif
  671. }
  672.     
  673.  
  674.  
  675. #ifdef WIN_MOTIF
  676.  
  677. #include <ncbi.h>
  678. #include <ncbidraw.h>
  679. //typedef unsigned long XID; // this is failing in X.h !?
  680. //#define XID  unsigned long
  681. #include <ncbiwin.h>
  682. #include <ncbiport.h>
  683.  
  684. extern Display      *Nlm_currentXDisplay;
  685. extern int          Nlm_currentXScreen;
  686. extern Window       Nlm_currentXWindow;
  687. extern GC           Nlm_currentXGC;
  688. extern Nlm_Uint4    Nlm_XbackColor;
  689. extern Nlm_Uint4    Nlm_XforeColor;
  690. extern Nlm_Int2     Nlm_XOffset;
  691. extern Nlm_Int2     Nlm_YOffset;
  692. extern Nlm_RegioN   Nlm_clpRgn;
  693.  
  694. #endif
  695.  
  696.  
  697. inline void DTableInvertRect( Nlm_RecT& r)
  698. {    
  699. #ifdef notWIN_MOTIF
  700. // vals: GXcopy  GXand  GXor GXequiv GXinvert GXorInverted
  701. // !! GXor looks GOOD for colored x -- makes gray rect
  702. // but isn't reverting to regular on deselect, unless click is in selrect !?? 
  703. // GXxor looks okay at start, but repeated calls mess it up (conflict??)
  704. // fill vals: FillStippled  FillOpaqueStippled  FillSolid  FillTiled
  705.  
  706. #define newfunc  GXxor
  707. #define currentFunction  GXcopy
  708. #define newfill  FillStippled
  709. #define currentFillStyle   FillStippled
  710.   Nlm_RectTool  rtool;
  711.  
  712. #if 1
  713.   if (Nlm_currentXDisplay && Nlm_currentXWindow && Nlm_currentXGC) {
  714.     rtool.x = MIN (r.left, r.right);
  715.     rtool.y = MIN (r.top, r.bottom);
  716.     rtool.width = ABS (r.right - r.left);
  717.     rtool.height = ABS (r.bottom - r.top);
  718.  
  719.         // ! recommended by Xlib vol 1, sect. 7.4.3: foreground( forecol ^ backcol)
  720.         // ! and it works !
  721.         ulong xorcolor= Nlm_XforeColor ^ Nlm_XbackColor;
  722.         XSetForeground( Nlm_currentXDisplay,Nlm_currentXGC, xorcolor);
  723.     XSetFunction (Nlm_currentXDisplay, Nlm_currentXGC, newfunc);
  724.     //XSetFillStyle (Nlm_currentXDisplay, Nlm_currentXGC, newfill);
  725.     XFillRectangle (Nlm_currentXDisplay, Nlm_currentXWindow, Nlm_currentXGC,
  726.                     rtool.x - Nlm_XOffset, rtool.y - Nlm_YOffset,
  727.                     rtool.width, rtool.height);
  728.     XSetFunction (Nlm_currentXDisplay, Nlm_currentXGC, currentFunction);
  729.     //XSetFillStyle (Nlm_currentXDisplay, Nlm_currentXGC, currentFillStyle);
  730.         XSetForeground( Nlm_currentXDisplay,Nlm_currentXGC, Nlm_XforeColor);
  731.    }
  732.  
  733. #else
  734.     Nlm_InvertMode();
  735.     Nlm_PaintRect( &r);
  736.     Nlm_CopyMode();
  737. #endif
  738.  
  739. #else
  740.     // patched both Nlm_InvertMode & Nlm_InvertRect for Motif
  741.   Nlm_InvertRect( &r);
  742. #endif 
  743. }
  744.  
  745. void DTableView::InvertRect( Nlm_RecT& r)
  746. {    
  747.     Nlm_WindoW w= Nlm_SavePort( fNlmObject);
  748. #ifdef WIN_MOTIF
  749.     this->Select();
  750. #endif
  751.     ::DTableInvertRect( r);
  752.     if (w) Nlm_UseWindow (w); 
  753. }
  754.  
  755. void DTableView::InvertSelection()
  756. {    
  757.     Nlm_RecT r, r2;
  758.     if (!Nlm_EmptyRect(&fSelrect)) {
  759.         r2= fSelrect;
  760.         //r2.bottom--;
  761.         //r2.right--;
  762.         GetCellRect( r2, r);
  763.         }
  764.     else if (fSelectedRow>=0 && fSelectedCol>=0) 
  765.         GetCellRect( fSelectedRow, fSelectedCol, r);
  766.     else if (fSelectedRow>=0) 
  767.         GetRowRect( fSelectedRow, r);
  768.     else if (fSelectedCol>=0) 
  769.         GetRowRect( fSelectedCol, r);
  770.   else
  771.       return;
  772.     InvertRect( r);
  773. }
  774.  
  775.  
  776.  
  777. void DTableView::DoubleClickAt(short row, short col)
  778. {
  779. }
  780.  
  781.  
  782. void DTableView::SingleClickAt(short row, short col)
  783. {
  784.     Nlm_PoinT pt;
  785.     pt.x= col; pt.y= row;
  786.     if (Nlm_PtInRect( pt, &fSelrect) && !gKeys->shift()) {
  787.         SetEmptySelection( true);
  788.         }
  789.     else {
  790.         SelectCells(  row, col, gKeys->shift(), kHighlight, kSelect);
  791.         }
  792. }
  793.             
  794.  
  795. void DTableView::PointToCell(Nlm_PoinT mouse, short& row, short& col)
  796. {
  797.     if (fHeights) {
  798.         row= fTop - 1;
  799.         short yrow= fRect.top;
  800.         do {
  801.             row++;
  802.             if (row<=fMaxRows) yrow += fHeights[row];
  803.             else yrow= mouse.y;
  804.             } while (yrow < mouse.y);
  805.         }
  806.     else
  807.         row= fTop  + (mouse.y - fRect.top)  / fItemHeight;
  808.  
  809.     if (fWidths) {
  810.         col= fLeft - 1;
  811.         short xcol= fRect.left;
  812.         do {
  813.             col++;
  814.             if (col<=fMaxCols) xcol += fWidths[col];
  815.             else xcol= mouse.x;
  816.             } while (xcol < mouse.x);
  817.         }
  818.     else
  819.         col= fLeft + (mouse.x - fRect.left) / fItemWidth;
  820. }
  821.  
  822.  
  823.  
  824. void DTableView::Click(Nlm_PoinT mouse)
  825. {
  826.     short row, col;
  827.     
  828.     //if (gLastCommand) gLastCommand->Commit();    //?? prevent bombs from prev. cmds ?
  829.     //if (fCurrentTracker) fCurrentTracker->Reset();
  830.     SetTracker( fCurrentTracker); // ??  make new one each click?
  831.     DAutoPanel::Click(mouse);         // sets fMouseStillDown= false
  832.  
  833.     if (!fCurrentTracker) {
  834.         // TrackMouse::trackEnd does this now, if click is tracked...
  835.         PointToCell( mouse, row, col);
  836.         if (row >=0 && row < fMaxRows && col >= 0 && col < fMaxCols) {
  837.             if (Nlm_dblClick) DoubleClickAt( row, col);
  838.             else SingleClickAt( row, col);
  839.             }
  840.         }
  841. }
  842.  
  843. void DTableView::Drag(Nlm_PoinT mouse)
  844. {
  845.     DAutoPanel::Drag(mouse); // sets fMouseStillDown= true,... 
  846. }
  847.  
  848. void DTableView::Release(Nlm_PoinT mouse)
  849. {
  850.     DAutoPanel::Release(mouse); // sets fMouseStillDown= false,... 
  851. }
  852.  
  853.  
  854. void DTableView::TrackMouse( short aTrackPhase,
  855.                     Nlm_PoinT& anchorPoint, Nlm_PoinT& previousPoint,
  856.                     Nlm_PoinT& nextPoint,    Nlm_Boolean mouseDidMove)
  857. {
  858.  
  859.     switch (aTrackPhase) {
  860.     
  861.         case DTracker::trackBegin:
  862.             if (gKeys->shift()) {  
  863.                 Nlm_PoinT pt;
  864.                 Nlm_RecT  pixr;
  865.                 short    diff1, diff2;
  866.                 
  867.                 GetCellRect( fSelrect, pixr);
  868.                 diff1= anchorPoint.x - pixr.left;
  869.                 diff2= anchorPoint.x - pixr.right;
  870.                 if (abs(diff1) > abs(diff2)) pt.x= pixr.left; 
  871.                 else pt.x= pixr.right;
  872.                 diff1= anchorPoint.y - pixr.top;
  873.                 diff2= anchorPoint.y - pixr.bottom;
  874.                 if (abs(diff1) > abs(diff2)) pt.y= pixr.top; 
  875.                 else pt.y= pixr.bottom;
  876.                 
  877.                 // tracker::Start makes 3 pts all same
  878.                 anchorPoint = pt;
  879.                 previousPoint = pt;
  880.                 nextPoint = pt;
  881.                 //fTracker->fMovedOnce= true; // force it for single-click extend?
  882.                 }
  883.              break;
  884.     
  885.         case DTracker::trackContinue:
  886.             break;
  887.             
  888.         case DTracker::trackEnd:
  889.             {
  890.             short row, col;
  891.             Boolean moved= gKeys->shift() // extend
  892.                     || abs(anchorPoint.x - nextPoint.x) > 2
  893.                     || abs(anchorPoint.y - nextPoint.y) > 2;
  894.             if (!moved) {
  895.                 PointToCell( nextPoint, row, col);
  896.                 if (row >=0 && row < fMaxRows && col >= 0 && col < fMaxCols) {
  897.                     if (Nlm_dblClick) DoubleClickAt( row, col);
  898.                     else SingleClickAt( row, col);
  899.                     }
  900.                 }
  901.             }
  902.             break;
  903.             
  904.         }
  905. }
  906.  
  907. void DTableView::TrackFeedback( short aTrackPhase,
  908.                     const Nlm_PoinT& anchorPoint, const Nlm_PoinT& previousPoint,
  909.                     const Nlm_PoinT& nextPoint, Nlm_Boolean mouseDidMove, Nlm_Boolean turnItOn)
  910. {
  911.     if (mouseDidMove) {
  912.         Nlm_RecT    pixr;
  913.  
  914.         pixr.left= MIN( anchorPoint.x, nextPoint.x);
  915.         pixr.right= MAX( anchorPoint.x, nextPoint.x);
  916.         pixr.top= MIN( anchorPoint.y, nextPoint.y);
  917.         pixr.bottom= MAX( anchorPoint.y, nextPoint.y);
  918.         
  919.         Nlm_InsetRect( &pixr, 1,1); //??
  920.         Nlm_InvertMode();
  921.         Nlm_FrameRect( &pixr);
  922.         Nlm_CopyMode();
  923.         }
  924. }
  925.  
  926.  
  927.  
  928.  
  929. void DTableView::DrawCell(Nlm_RecT r, short row, short col)
  930. {
  931.     char    snum[80];
  932.     sprintf(snum,"r%d,c%d", row, col);
  933.     Nlm_DrawString( &r, snum, 'c', false);
  934. }
  935.     
  936. void DTableView::DrawRow(Nlm_RecT r, short row)
  937. {
  938.     short col = fLeft; 
  939.     if (fWidths && col <= fMaxCols) r.right= r.left + fWidths[col];
  940.     else r.right= r.left + fItemWidth;
  941.     while (r.left < fRect.right && col < fMaxCols) {
  942.         if (Nlm_RectInRgn (&r, Nlm_updateRgn))  
  943.             DrawCell( r, row, col);
  944.         if (fWidths) {
  945.             Nlm_OffsetRect( &r, fWidths[col], 0);
  946.             r.right= r.left + fWidths[col+1];
  947.             }
  948.         else
  949.             Nlm_OffsetRect( &r, fItemWidth, 0);
  950.         col++;
  951.         }
  952.     fColsDrawn= col - fLeft;
  953. }
  954.  
  955.  
  956. void DTableView::GetPageCount(Nlm_RecT pagerect, short& rowpages, short& colpages)
  957. {
  958.     long left, top, row, col;     
  959.     rowpages= colpages= 1;
  960.     
  961.     for (col=0, left=0; col < fMaxCols; col++) {
  962.         if (fWidths) left += fWidths[col];  
  963.         else left += fItemWidth;
  964.         if (left >= pagerect.right) { 
  965.             colpages++; 
  966.             left= 0; 
  967.             }
  968.         }
  969.     for (row=0, top=0; row < fMaxRows; row++) {
  970.         if (fHeights) top += fHeights[row];  
  971.         else top += fItemHeight;
  972.         if (top >= pagerect.bottom) { 
  973.             rowpages++; 
  974.             top= 0; 
  975.             }
  976.         }
  977. }
  978.  
  979.  
  980. void DTableView::Draw()
  981. {
  982.     Nlm_RecT         r2, r = fRect;
  983.     Nlm_PoinT      pt;
  984.     short             row = fTop; 
  985.     Boolean            hasSel;
  986.     
  987.     if (fHeights) r.bottom= r.top + fHeights[row];
  988.     else r.bottom= r.top + fItemHeight;
  989.     Nlm_SelectFont(fFont); //?? here
  990.     hasSel= !Nlm_EmptyRect(&fSelrect);
  991.     if (hasSel) {
  992.         pt.x= fSelrect.left;
  993.         r2= fSelrect;
  994.         GetCellRect( r2, r2);
  995.         }
  996.         
  997.     while (r.top < fRect.bottom && row < fMaxRows) {
  998.         if (Nlm_RectInRgn (&r, Nlm_updateRgn)) { 
  999.             DrawRow( r, row);
  1000.              pt.y= row;
  1001.              if (hasSel && Nlm_PtInRect( pt, &fSelrect)) {
  1002.                  Nlm_RecT ir= r;
  1003.                  ir.left= r2.left;
  1004.                  ir.right= r2.right;
  1005.                 InvertRect( ir);
  1006.                  }
  1007.           }
  1008.         if (fHeights) {
  1009.             Nlm_OffsetRect( &r, 0, fHeights[row]);
  1010.             r.bottom= r.top + fHeights[row+1];
  1011.             }
  1012.         else
  1013.             Nlm_OffsetRect( &r, 0, fItemHeight);
  1014.         row++;
  1015.         }
  1016. }
  1017.         
  1018.  
  1019. enum { kWritingAsPICT = 9 };
  1020.  
  1021. void DTableView::ViewRect(Nlm_RecT& r) 
  1022. { 
  1023.     if (fIsPrinting == kWritingAsPICT) {
  1024.         r= fRect; // fRect is set at start of AsPICT
  1025.         }
  1026.     else if (fIsPrinting) {
  1027.         r= fRect; //fRect is set at start of Print 
  1028.         // Nlm_PrintingRect(&r);
  1029.         }
  1030.     else
  1031.         DView::ViewRect(r);  
  1032. }
  1033.         
  1034. void DTableView::Print()  
  1035. {
  1036. #if (defined(WIN_MAC) || defined (WIN_MSWIN))
  1037.   Nlm_WindoW    w;
  1038.   Boolean           goOn, newPage, widerThanPage;
  1039.   Nlm_RecT        pager, r, saverect;
  1040.     short                 row = 0, rowpages, colpages; 
  1041.     long                    saveleft;
  1042.     
  1043.     // problems: assumes each row < page height
  1044.     
  1045.   w = Nlm_StartPrinting();
  1046.   if (w) {
  1047.       fIsPrinting= true;
  1048.         gCursor->watch();    
  1049.         saverect= fRect;
  1050.         Nlm_PrintingRect(&pager);
  1051.         fRect= pager;
  1052.         Nlm_SelectFont(fFont); 
  1053.         saveleft= fLeft; fLeft= 0; 
  1054.         //savetop= fTop; fTop= 0; 
  1055.         GetPageCount( pager, rowpages, colpages);
  1056.         
  1057.     newPage = true;
  1058.     goOn = row < fMaxRows;
  1059.     widerThanPage= colpages > 1; 
  1060.     
  1061.     // make update region large...
  1062.     if (Nlm_updateRgn != NULL)  
  1063.             Nlm_LoadRectRgn(Nlm_updateRgn, -32767, -32767, 32767, 32767);
  1064.     
  1065.     while (goOn) {
  1066.     
  1067.       if (newPage) {
  1068.         goOn = Nlm_StartPage();
  1069.         newPage = false;
  1070.           r= pager;
  1071.           
  1072.                 if (fHeights) r.bottom= r.top + fHeights[row];
  1073.                 else r.bottom= r.top + fItemHeight;
  1074.            }
  1075.       
  1076.       if (goOn) {
  1077.                 fColsDrawn= fMaxCols; // in case DrawRow forgets to set this
  1078.                 DrawRow( r, row);
  1079.                 
  1080.                 if (widerThanPage) {
  1081.                   fLeft +=     fColsDrawn;
  1082.                     newPage = (fLeft < fMaxCols);
  1083.                     if (newPage) goOn = Nlm_EndPage();    
  1084.                     else fLeft= 0;
  1085.                     }
  1086.                 
  1087.                 if (!newPage) {    
  1088.                     if (fHeights) {
  1089.                         Nlm_OffsetRect( &r, 0, fHeights[row]);
  1090.                         r.bottom= r.top + fHeights[row+1];
  1091.                         }
  1092.                     else
  1093.                         Nlm_OffsetRect( &r, 0, fItemHeight);
  1094.                     newPage = (r.bottom > pager.bottom);
  1095.                     if (newPage) goOn = Nlm_EndPage();    
  1096.                     row++;
  1097.                     if (goOn) goOn= (row < fMaxRows);
  1098.                     }
  1099.                     
  1100.                 }
  1101.             }
  1102.             
  1103.           if (!newPage) (void) Nlm_EndPage();
  1104.       Nlm_EndPrinting(w);
  1105.         fIsPrinting= false;
  1106.         fRect= saverect;
  1107.         fLeft= saveleft;
  1108.         gCursor->arrow();
  1109.         }       
  1110. #else
  1111.     Nlm_Message(MSG_OK,"Printing is not yet defined for this window system");
  1112. #endif
  1113. }
  1114.  
  1115.  
  1116. #ifdef WIN_MAC
  1117. #undef Handle
  1118. #undef Rect
  1119. #include <QuickDraw.h>
  1120. #include <Memory.h>
  1121. #endif
  1122.  
  1123. #ifdef WIN_MSWIN
  1124. #undef FAR 
  1125. #undef NEAR 
  1126. #include <windows.h>
  1127. extern "C" HWND         Nlm_currentHWnd;
  1128. extern "C" HDC          Nlm_currentHDC;
  1129.  
  1130. struct METAFILEHEADER { // must be 22 bytes !
  1131.     DWORD    key;
  1132.     WORD    hmf; // HANDLE hmf; for Win16 !
  1133.     //RECT    bbox; for Win16 !
  1134.     WORD  boxleft;
  1135.     WORD  boxtop;
  1136.     WORD  boxright;
  1137.     WORD  boxbottom;
  1138.     WORD    inch;
  1139.     DWORD    reserved;
  1140.     WORD    checksum;
  1141. };
  1142.  
  1143.       
  1144. void CalcMFChecksum(METAFILEHEADER* pMFHead)
  1145. {
  1146.   WORD *p;
  1147.  
  1148.   for (p =(WORD *)pMFHead, pMFHead->checksum = 0;
  1149.          p < (WORD *)&pMFHead->checksum; ++p)
  1150.          pMFHead->checksum ^= *p;
  1151. }
  1152.  
  1153. #endif
  1154.  
  1155. void DTableView::WriteToPICT(DFile* afile)  
  1156. {
  1157.     if (!afile) return;
  1158.     
  1159. #ifdef WIN_MAC
  1160.   Nlm_RecT        pager, saverect, cellr;
  1161.     
  1162.     gCursor->watch();    
  1163.     saverect= fRect;
  1164.      fIsPrinting= kWritingAsPICT;
  1165.      Nlm_LoadRect( &cellr, 0, 0, fMaxCols, fMaxRows);
  1166.     this->GetCellRect( cellr, pager);
  1167.     fRect= pager;
  1168.     
  1169.   Rect  picrect;
  1170.   picrect.left= pager.left;
  1171.   picrect.right= pager.right;
  1172.   picrect.top = pager.top;
  1173.   picrect.bottom= pager.bottom;
  1174.     Handle pic= (Handle) OpenPicture( &picrect); 
  1175.     
  1176.   if (pic) { 
  1177.       enum { kPicHeadsize = 512 };
  1178.       ulong count;
  1179.         // make update region large...
  1180.     if (Nlm_updateRgn != NULL)  
  1181.             Nlm_LoadRectRgn(Nlm_updateRgn, -32767, -32767, 32767, 32767);
  1182.     Draw();                
  1183.       ClosePicture();
  1184.       
  1185.           // now write pic to file
  1186.       afile->Delete();
  1187.       afile->Create("PICT","ttxt"); 
  1188.         afile->Open("wb"); // Damn "wb" -- must by BINARY 
  1189.       count= kPicHeadsize;
  1190.       char * header = (char *) Nlm_MemGet(kPicHeadsize,MGET_CLEAR);
  1191.       afile->WriteData( header, count);
  1192.       Nlm_MemFree( header);
  1193.         HLock(pic);
  1194.       count= GetHandleSize(pic);
  1195.       afile->WriteData( *pic, count);
  1196.       afile->Close();
  1197.       HUnlock(pic);
  1198.       KillPicture ( (PicHandle)pic);
  1199.         } 
  1200.     fIsPrinting= false;        
  1201.     fRect= saverect;
  1202.     gCursor->arrow();
  1203.     return;
  1204. #endif
  1205.  
  1206. #ifdef WIN_MSWIN
  1207.   Nlm_RecT        pager, saverect, cellr;
  1208.   RECT  picrect;
  1209.     
  1210.     gCursor->watch();    
  1211.     saverect= fRect;
  1212.      fIsPrinting= kWritingAsPICT;
  1213.      Nlm_LoadRect( &cellr, 0, 0, fMaxCols, fMaxRows);
  1214.     this->GetCellRect( cellr, pager);
  1215.     fRect= pager;
  1216.   picrect.left= pager.left;
  1217.   picrect.top = pager.top;
  1218.   picrect.right = pager.right;
  1219.   picrect.bottom= pager.bottom;
  1220.     
  1221.     char* fname= (char*) afile->GetName();
  1222.     fname= (char*)DFileManager::FilenameFromPath(fname); // CreateMF fails for full path !?
  1223.     //fname= "test.wmf";
  1224.     
  1225. #if 1
  1226. //#ifdef WIN16
  1227.     HDC hdcMeta= CreateMetaFile(fname); // (fname)
  1228.     
  1229. #define MetaHandle HMETAFILE
  1230. #define MetaClose(x)  CloseMetaFile(x)
  1231. #define MetaDelete(x) DeleteMetaFile(x)
  1232. #define MetaGetData(a,b,c)  GetMetaFileBitsEx(a,b,c)
  1233.  
  1234. #else
  1235.   char  describes[120];
  1236.   char  titlebuf[80];
  1237.   char  *dp, *np, *ep;
  1238.   
  1239.   np= (char*)gApplication->Shortname();
  1240.   dp= describes;
  1241.   ep= dp + sizeof(describes) - 2;
  1242.   if (np) while (*np && dp < ep) { *dp++ = *np++; }
  1243.   *dp++ = 0;
  1244.   np= this->GetTitle(titlebuf, sizeof(titlebuf));
  1245.   if (np) while (*np && dp < ep) { *dp++ = *np++; }
  1246.   *dp++ = 0;
  1247.  
  1248.   // need pixel to .01 mm conversion for picrect !
  1249.   // need some needlessly complex SetMapMode, MapPoint, ResetMapMode...
  1250.   
  1251.     HDC hdcMeta= CreateEnhMetaFile( Nlm_currentHDC, NULL, &picrect, describes);
  1252. #define MetaHandle HENHMETAFILE
  1253. #define MetaClose(x)  CloseEnhMetaFile(x)
  1254. #define MetaDelete(x) DeleteEnhMetaFile(x)
  1255. #define MetaGetData(a,b,c)  GetEnhMetaFileBits(a,b,c)
  1256. #endif
  1257.  
  1258.   if (hdcMeta) { 
  1259.       POINT point;
  1260.       SIZE  size;
  1261.  
  1262.        HDC savehdc= Nlm_currentHDC;
  1263.       Nlm_currentHDC= hdcMeta;  
  1264.       SetMapMode( hdcMeta, MM_ANISOTROPIC);
  1265.         SetWindowOrgEx(hdcMeta, 0,0, &point);
  1266.         SetWindowExtEx(hdcMeta, picrect.right-picrect.left, 
  1267.                         picrect.bottom-picrect.top, &size);
  1268.  
  1269.       Nlm_ResetDrawingTools();
  1270.       
  1271.         // make update region large...
  1272.     if (Nlm_updateRgn != NULL)  
  1273.             Nlm_LoadRectRgn(Nlm_updateRgn, -32767, -32767, 32767, 32767);
  1274.     Draw();  
  1275.       
  1276.       MetaHandle hmf = MetaClose( hdcMeta);
  1277.  
  1278. #ifdef WIN16
  1279.       // win16 code
  1280.       //HGLOBAL hgmf = GetMetaFileBits( hmf);
  1281. #else
  1282.       // win32 code
  1283.       ulong count, bufsize;
  1284.       METAFILEHEADER placeheader;
  1285.       bufsize= GetEnhMetaFileBits( hmf, 0, NULL);
  1286.       char* buf= (char*) MemNew( bufsize + 1);
  1287.       if ( GetEnhMetaFileBits( hmf, bufsize, (unsigned char*)buf) ) { 
  1288.         placeheader.key= 0x9AC6CDD7L;
  1289.         placeheader.hmf= 0;
  1290.         //c0 f4 90 f7 36 0b 66 08 is bbox rect that powerpnt made
  1291.         placeheader.boxtop = 0xf4c0; //picrect.top; //?? some neg.num?
  1292.         placeheader.boxleft= 0xf790; //picrect.left;  //?? some neg.num?
  1293.         placeheader.boxbottom= 0x0b36; //picrect.bottom;
  1294.         placeheader.boxright = 0x0866; //picrect.right;
  1295.         placeheader.inch= 576;
  1296.         placeheader.reserved= 0;
  1297.         placeheader.checksum= 0x5551;  
  1298.         CalcMFChecksum( &placeheader); // == 0x5551 ?
  1299.     
  1300.         afile->Delete();
  1301.         afile->Create("WMF","DCLAP"); 
  1302.           afile->Open("wb"); 
  1303.         count= 22; //!! not -> sizeof(placeheader);
  1304.         afile->WriteData( &placeheader, count);
  1305.         count= bufsize;
  1306.         afile->WriteData( buf, count);  
  1307.         afile->Close();
  1308.         }
  1309.       MemFree( buf);
  1310. #endif
  1311.  
  1312.       MetaDelete( hmf); // just deletes handle, not disk file !
  1313.       Nlm_currentHDC= savehdc;  
  1314.         }       
  1315.     fIsPrinting= false;        
  1316.     fRect= saverect;
  1317.     gCursor->arrow();
  1318.     return;
  1319. #endif
  1320.       
  1321.     Nlm_Message(MSG_OK,"DrawToPicture is not yet defined for this window system");
  1322. }
  1323.  
  1324.